﻿<h1>结构体</h1>

<p>
和C语言类似，Go也支持结构体类型。此篇文章将介绍Go中的结构体类型和结构体值做一个详细的解释。
</p>

<h3>结构体类型和结构体字面量表示形式</h3>

<div>
每个非定义结构体类型的字面形式均由<code>struct</code>关键字开头，后面跟着用一对大括号<code>{}</code>，其中包裹着的一系列字段（field）声明。
一般来说，每个字段声明由一个字段名和字段类型组成。一个结构体类型的字段数目可以为0。下面是一个非定义结构体类型的字面形式：

<pre class="line-numbers"><code class="language-go">struct {
	title  string
	author string
	pages  int
}
</code></pre>

<p>
上面这个结构体类型含有三个字段。前两个字段（<code>title</code>和<code>author</code>）的类型均为<code>string</code>。
最后一个字段<code>pages</code>的类型为<code>int</code>。
</p>

<p>
有时字段也称为成员变量。
</p>

相邻的同类型字段可以声明在一起。比如上面这个类型也可表示成下面这样：
<pre class="line-numbers"><code class="language-go">struct {
	title, author string
	pages         int
}
</code></pre>

<p>
一个结构体类型的尺寸为它的所有字段的（类型）尺寸之和加上一些填充字节的数目。
常常地，编译器（和运行时）会在一个结构体值的两个相邻字段之间填充一些字节来保证一些字段的地址总是某个整数的倍数。
我们可以在后面的<a href="memory-layout.html">内存布局</a>一文中了解到字节填充（padding）和内存地址对齐（memory address alignment）。
</p>

<p>
一个零字段结构体的尺寸为零。
</p>

每个结构体字段在它的声明中可以被指定一个标签（tag）。从语法上讲，字段标签可以是任意字符串，它们是可选的，默认为空字符串。
但在实践中，它们应该被表示成用空格分隔的键值对形式，并且每个标签尽量使用直白字面形式（<code>`...`</code>）表示，而键值对中的值使用解释型字面形式（<code>"..."</code>）表示。
比如下例：

<pre class="line-numbers"><code class="language-go">struct {
	Title  string `json:"title" myfmt:"s1"`
	Author string `json:"author,omitempty" myfmt:"s2"`
	Pages  int    `json:"pages,omitempty" myfmt:"n1"`
	X, Y   bool   `myfmt:"b1"`
}
</code></pre>

<p>
注意：上例中的<code>X</code>和<code>Y</code>字段的标签是一样的（尽管在实践中基本上从不会这样使用字段标签）。
</p>

<p>
我们可以使用<a href="reflection.html#struct-field-tag">反射</a>来检视字段的标签信息。
</p>

<p>
每个字段标签的目的取决于具体应用。上面这个例子中的字段标签用来帮助<code>encoding/json</code>标准库包来将上面这个结构体类型的某个值编码成JSON数据或者从一份JSON数据解码到上面这个结构体类型的某个值中。在编码和解码过程中，<code>encoding/json</code>标准库包中的函数将只考虑导出的结构体字段。这是为什么上面这个结构体的字段均为导出的。
</p>

<p>
把字段标签当成字段注释来使用不是一个好主意。
</p>



<p>
和C语言不一样，Go结构体不支持字段联合（union）。
</p>

<p>
上面的例子中展示的结构体类型都是非定义的和匿名的。在实践中，定义的结构体类型用得更流行。
</p>

<p>
只有导出字段可以被使用在其它代码包中。非导出字段类以于很多其它语言中的私有或者保护型的成员变量。
</p>

<p>
一个结构体类型中的字段标签和字段的声明顺序对此结构体类型的身份识别很重要。
如果两个非定义结构体类型的各个对应字段声明都相同（按照它们的出现顺序），则此两个非定义结构体类型是等同的。
两个字段声明只有在它们的名称、类型和标签都等同的情况下才相同。
注意：<b>两个声明在不同的代码包中的非导出字段将总被认为是不同的字段。</b>
</p>

<p>
一个结构体类型不能（直接或者间接）含有一个类型为此结构类型的字段。
</p>
<!--
https://github.com/golang/go/issues/18640
-->

</div>

<h3>结构体字面量表示形式和结构体值的使用</h3>

<p>
在Go中，语法形式<code>T{...}</code>称为一个组合字面量形式（composite literal），其中<code>T</code>必须为一个类型名或者类型字面形式。
组合字面量形式可以用来表示结构体类型和内置容器类型（将在后面的文章中介绍）的值。
</p>

<p>
注意：组合字面量<code>T{...}</code>是一个类型确定值，它的类型为<code>T</code>。
</p>

<div>
假设<code>S</code>是一个结构体类型并且它的底层类型为<code>struct{ x int; y bool}</code>，<code>S</code>的零值可以表示成下面所示的组合字面量两种变种形式：
<ol>
<li>
	<code>S{0, false}</code>。在此变种形式中，所有的字段名称均不出现，但每个字段的值必须指定，并且每个字段的出现顺序和它们的声明顺序必须一致。
</li>
<li>
	<code>S{x: 0, y: false}</code>、<code>S{y: false, x: 0}</code>、<code>S{x: 0}</code>、<code>S{y: false}</code>和<code>S{}</code>。
	在此变种形式中，字段的名称和值必须成对出现，但是每个字段都不是必须出现的，并且字段的出现顺序并不重要。
	没有出现的字段的值被编译器认为是它们各自类型的零值。<code>S{}</code>是最常用的类型<code>S</code>的零值的表示形式。
</li>
</ol>

<p>
如果<code>S</code>是声明在另一个代码包中的一个结构体类型，则推荐使用上面所示的第二种变种形式来表示它的值。
因为另一个代码包的维护者今后可能会在此结构体中添加新的字段，从而导致当前使用的第一种变种形式在今后可能编译不通过。
</p>

<p>
当然，上面所示的结构体值的组合字面量也可以用来表示结构体类型的非零值。
</p>

<p>
对于类型<code>S</code>的一个值<code>v</code>，我们可以用<code>v.x</code>和<code>v.y</code>来表示它的字段。
<code>v.x</code>（或<code>v.y</code>）这种形式称为一个选择器（selector）。其中的<code>v</code>称为此选择器的属主。
今后，我们称一个选择器中的句点<code>.</code>为属性选择操作符。
</p>

一个例子：
<pre class="line-numbers"><code class="language-go">package main

import (
	"fmt"
)

type Book struct {
	title, author string
	pages         int
}

func main() {
	book := Book{"Go语言101", "老貘", 256}
	fmt.Println(book) // {Go语言101 老貘 256}

	// 使用带字段名的组合字面量来表示结构体值。
	book = Book{author: "老貘", pages: 256, title: "Go语言101"}
	// title和author字段的值都为空字符串""，pages字段的值为0。
	book = Book{}
	// title字段空字符串""，pages字段为0。
	book = Book{author: "老貘"}

	// 使用选择器来访问和修改字段值。
	var book2 Book // <=> book2 := Book{}
	book2.author = "Tapir"
	book2.pages = 300
	fmt.Println(book2.pages) // 300
}
</code></pre>

<p></p>

如果一个组合字面量中最后一项和结尾的<code>}</code>处于同一行，则此项后的逗号<code>,</code>是可选的；否则此逗号不可省略。
我们可以阅读后面的<a href="line-break-rules.html">Go代码断行规则</a>一文了解更多断行规则。

<pre class="line-numbers"><code class="language-go">var _ = Book {
	author: "老貘",
	pages: 256,
	title: "Go语言101", // 这里行尾的逗号不可省略
}

// 下行}前的逗号可以省略。
var _ = Book{author: "老貘", pages: 256, title: "Go语言101",}
</code></pre>

<p>
</p>

</div>

<h3>关于结构体值的赋值</h3>

<div>
当一个（源）结构体值被赋值给另外一个（目标）结构体值时，其效果和逐个将源结构体值的各个字段赋值给目标结构体值的各个对应字段的效果是一样的。

<pre class="line-numbers"><code class="language-go">func f() {
	book1 := Book{pages: 300}
	book2 := Book{"Go语言101", "老貘", 256}

	book2 = book1
	// 上面这行和下面这三行是等价的。
	book2.title = book1.title
	book2.author = book1.author
	book2.pages = book1.pages
}
</code></pre>

<p>
两个结构体值只有在它们的类型相同或者的它们的底层类型相同（要考虑字段标签）并且其中至少有一个结构体值的类型为<a href="type-system-overview.html#non-defined-type">非定义类型</a>时（换句话说，只有它们可以被隐式转换为对方的类型的时候，见下）才可以互相赋值。
</p>

</div>

<a class="anchor" id="field-addressability"></a>
<h3>结构体字段的可寻址性</h3>

<div>
<p>
如果一个结构体值是可寻址的，则它的字段也是可寻址的；反之，一个不可寻址的结构的字段也是不可寻址的。
不可寻址的字段的值是不可更改的。所有的组合字面量都是不可寻址的。
</p>

一个例子：
<pre class="line-numbers"><code class="language-go">package main

import "fmt"

func main() {
	type Book struct {
		Pages int
	}
	var book = Book{} // 变量值book是可寻址的
	p := &book.Pages
	*p = 123
	fmt.Println(book) // {123}

	// 下面这两行编译不通过，因为Book{}是不可寻址的，
	// 继而Book{}.Pages也是不可寻址的。
	/*
	Book{}.Pages = 123
	p = &Book{}.Pages // <=> p = &(Book{}.Pages)
	*/
}
</code></pre>

<p>
注意：选择器中的属性选择操作符<code>.</code>的优先级比取地址操作符<code>&amp;</code>的优先级要高。
</p>

</div>

<a class="anchor" id="take-composite-literal-address"></a>
<h3>组合字面量不可寻址但可被取地址</h3>

<div>
<p>
一般来说，只有可被寻址的值才能被取地址，但是Go中有一个语法糖（语法例外）：虽然所有的组合字面量都是不可寻址的，但是它们都可被取地址。
</p>

例子：
<pre class="line-numbers"><code class="language-go">package main

func main() {
	type Book struct {
		Pages int
	}
	// Book{100}是不可寻址的，但是它可以被取地址。
	p := &Book{100} // <=> tmp := Book{100}; p := &tmp
	p.Pages = 200
}
</code></pre>
</div>

<a class="anchor" id="use-pointer-as-struct"></a>
<h3>在选择器中，结构体值的指针可以当作结构值来使用</h3>

<div>
<p>
和C语言不同，Go中没有<code>-&gt;</code>操作符用来通过一个结构体值的指针来访为此结构体值的字段。
在Go中，<code>-&gt;</code>操作符也是用句点<code>.</code>来表示的。
</p>

一个例子：
<pre class="line-numbers"><code class="language-go">package main

func main() {
	type Book struct {
		pages int
	}
	book1 := &Book{100} // book1是一个指针
	book2 := new(Book)  // book2是另外一个指针
	// 像使用结构值一样来使用结构体值的指针。
	book2.pages = book1.pages
	// 上一行等价于下一行。换句话说，上一行
	// 两个选择器中的指针属主将被自动解引用。
	(*book2).pages = (*book1).pages
}
</code></pre>

<p>
</p>

</div>

<a class="anchor" id="comparison"></a>
<h3>关于结构体值的比较</h3>

<p>
如果一个结构体类型是可比较的，则它肯定不包含<a href="type-system-overview.html#types-not-support-comparison">不可比较类型</a>的字段（这里不忽略名为空标识符<code>_</code>的字段）。
</p>

<p>
和结构体值的赋值规则类似，如果两个结构体值的类型均为可比较类型，则它们仅在它们的类型相同或者它们的底层类型相同（要考虑字段标签）并且其中至少有一个结构体值的类型为非定义类型时才可以互相比较。
</p>

<p>
如果两个结构体值可以相互比较，则它们的比较结果等同于逐个比较它们的相应字段（按照字段在代码中的声明顺序）。
两个结构体值只有在它们的相应字段都相等的情况下才相等；当一对字段被发现不相等的或者<a href="interface.html#comparison">在比较中产生恐慌</a>的时候，对结构体的比较将提前结束结束。
在比较中，名为空标识符<code>_</code>的字段将被忽略掉。
</p>

<h3>关于结构体值的类型转换</h3>

<div>
<p>
两个类型分别为<code>S1</code>和<code>S2</code>的结构体值只有在<code>S1</code>和<code>S2</code>的底层类型相同（忽略掉字段标签）的情况下才能相互转换为对方的类型。
特别地，如果<code>S1</code>和<code>S2</code>的底层类型相同（要考虑字段标签）并且只要它们其中有一个为非定义类型，则此转换可以是隐式的。
</p>

比如，对于下面的代码片段中所示的五个结构体类型：<code>S0</code>、<code>S1</code>、<code>S2</code>、<code>S3</code>和<code>S4</code>：
<ul>
<li>
	类型<code>S0</code>的值不能被转换为其它四个类型中的任意一个，原因是它与另外四个类型的对应字段名不同（因此底层类型不同）。
</li>
<li>
	类型<code>S1</code>、<code>S2</code>、<code>S3</code>和<code>S4</code>的任意两个值可以转换为对方的类型。
</li>
</ul>

特别地，
<ul>
<li>
	<code>S2</code>表示的类型的值可以被隐式转化为类型<code>S3</code>，反之亦然。
</li>
<li>
	<code>S2</code>表示的类型的值可以被隐式转换为类型<code>S4</code>，反之亦然。
</li>
</ul>

但是，
<ul>
<li>
	<code>S2</code>表示的类型的值必须被显式转换为类型<code>S1</code>，反之亦然。
</li>
<li>
	类型<code>S3</code>的值必须被显式转换为类型<code>S4</code>，反之亦然。
</li>
</ul>

<pre class="line-numbers"><code class="language-go">package main

type S0 struct {
	y int "foo"
	x bool
}

type S1 = struct { // S1是一个非定义类型
	x int "foo"
	y bool
}

type S2 = struct { // S2也是一个非定义类型
	x int "bar"
	y bool
}

type S3 S2 // S3是一个定义类型。
type S4 S3 // S4是一个定义类型。
// 如果不考虑字段标签，S3（S4）和S1的底层类型一样。
// 如果考虑字段标签，S3（S4）和S1的底层类型不一样。

var v0, v1, v2, v3, v4 = S0{}, S1{}, S2{}, S3{}, S4{}
func f() {
	v1 = S1(v2); v2 = S2(v1)
	v1 = S1(v3); v3 = S3(v1)
	v1 = S1(v4); v4 = S4(v1)
	v2 = v3; v3 = v2 // 这两个转换可以是隐式的
	v2 = v4; v4 = v2 // 这两个转换也可以是隐式的
	v3 = S3(v4); v4 = S4(v3)
}
</code></pre>

<p>
</p>

<p>
事实上，两个结构体值只有在它们可以相互隐式转换为对方的类型的时候才能相互赋值和比较。
</p>

</div>

<h3>匿名结构体类型可以使用在结构体字段声明中</h3>

<div>
<p>
匿名结构体类型允许出现在结构体字段声明中。匿名结构体类型也允许出现在组合字面量中。
</p>

一个例子：
<pre class="line-numbers"><code class="language-go">var aBook = struct {
	author struct { // 此字段的类型为一个匿名结构体类型
		firstName, lastName string
		gender              bool
	}
	title string
	pages int
}{
	author: struct {
		firstName, lastName string
		gender              bool
	}{
		firstName: "Mark",
		lastName: "Twain",
	}, // 此组合字面量中的类型为一个匿名结构体类型
	title: "The Million Pound Note",
	pages: 96,
}
</code></pre>

<p>
通常来说，为了代码可读性，最好少使用匿名结构体类型。
</p>

</div>

<h3>更多关于结构体类型</h3>

<p>
Go中有一些和结构体类型相关的进阶知识点。这些知识点将后面的<a href="type-embedding.html">类型内嵌</a>和<a href="memory-layout.html#size-and-padding">内存布局</a>两篇文章中介绍。
</p>


